package org.cybzacg.encryption.batch;

import org.cybzacg.encryption.context.EncryptionContext;
import org.cybzacg.encryption.model.EncryptionResult;
import org.cybzacg.encryption.model.ValidationResult;

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;

/**
 * 批处理器接口
 * 提供批量加密处理功能
 * 
 * @author encryption team
 * @version 1.0
 */
public interface BatchProcessor<T, R> {
    
    /**
     * 批量处理数据
     * 
     * @param dataList 数据列表
     * @param context 加密上下文
     * @param processor 处理函数
     * @return 处理结果列表
     */
    List<R> processBatch(List<T> dataList, EncryptionContext context, Function<T, R> processor);
    
    /**
     * 异步批量处理数据
     * 
     * @param dataList 数据列表
     * @param context 加密上下文
     * @param processor 处理函数
     * @return 处理结果Future
     */
    CompletableFuture<List<R>> processBatchAsync(List<T> dataList, EncryptionContext context, Function<T, R> processor);
    
    /**
     * 批量加密数据
     * 
     * @param dataList 待加密数据列表
     * @param context 加密上下文
     * @return 加密结果列表
     */
    List<EncryptionResult> encryptBatch(List<byte[]> dataList, EncryptionContext context);
    
    /**
     * 异步批量加密数据
     * 
     * @param dataList 待加密数据列表
     * @param context 加密上下文
     * @return 加密结果Future
     */
    CompletableFuture<List<EncryptionResult>> encryptBatchAsync(List<byte[]> dataList, EncryptionContext context);
    
    /**
     * 批量解密数据
     * 
     * @param dataList 待解密数据列表
     * @param context 加密上下文
     * @return 解密结果列表
     */
    List<byte[]> decryptBatch(List<byte[]> dataList, EncryptionContext context);
    
    /**
     * 异步批量解密数据
     * 
     * @param dataList 待解密数据列表
     * @param context 加密上下文
     * @return 解密结果Future
     */
    CompletableFuture<List<byte[]>> decryptBatchAsync(List<byte[]> dataList, EncryptionContext context);
    
    /**
     * 获取批次大小
     * 
     * @return 批次大小
     */
    int getBatchSize();
    
    /**
     * 设置批次大小
     * 
     * @param batchSize 批次大小
     */
    void setBatchSize(int batchSize);
    
    /**
     * 获取最大并发数
     * 
     * @return 最大并发数
     */
    int getMaxConcurrency();
    
    /**
     * 设置最大并发数
     * 
     * @param maxConcurrency 最大并发数
     */
    void setMaxConcurrency(int maxConcurrency);
    
    /**
     * 获取超时时间（毫秒）
     * 
     * @return 超时时间
     */
    long getTimeout();
    
    /**
     * 设置超时时间（毫秒）
     * 
     * @param timeout 超时时间
     */
    void setTimeout(long timeout);
    
    /**
     * 验证批处理配置
     * 
     * @param context 加密上下文
     * @return 验证结果
     */
    ValidationResult validateConfiguration(EncryptionContext context);
    
    /**
     * 获取批处理统计信息
     * 
     * @return 批处理统计信息
     */
    BatchStatistics getStatistics();
    
    /**
     * 重置统计信息
     */
    void resetStatistics();
    
    /**
     * 批处理结果接口
     */
    interface BatchResult<R> {
        
        /**
         * 获取成功的结果列表
         * 
         * @return 成功结果列表
         */
        List<R> getSuccessResults();
        
        /**
         * 获取失败的结果列表
         * 
         * @return 失败结果列表
         */
        List<BatchError<R>> getFailedResults();
        
        /**
         * 获取总数据量
         * 
         * @return 总数据量
         */
        int getTotalCount();
        
        /**
         * 获取成功数量
         * 
         * @return 成功数量
         */
        int getSuccessCount();
        
        /**
         * 获取失败数量
         * 
         * @return 失败数量
         */
        int getFailureCount();
        
        /**
         * 获取成功率
         * 
         * @return 成功率（0.0-1.0）
         */
        double getSuccessRate();
        
        /**
         * 获取处理时间（毫秒）
         * 
         * @return 处理时间
         */
        long getProcessingTime();
        
        /**
         * 检查是否全部成功
         * 
         * @return 是否全部成功
         */
        boolean isAllSuccess();
        
        /**
         * 检查是否有失败
         * 
         * @return 是否有失败
         */
        boolean hasFailures();
    }
    
    /**
     * 批处理错误接口
     */
    interface BatchError<R> {
        
        /**
         * 获取原始数据
         * 
         * @return 原始数据
         */
        Object getOriginalData();
        
        /**
         * 获取错误信息
         * 
         * @return 错误信息
         */
        String getErrorMessage();
        
        /**
         * 获取异常
         * 
         * @return 异常
         */
        Exception getException();
        
        /**
         * 获取错误类型
         * 
         * @return 错误类型
         */
        ErrorType getErrorType();
        
        /**
         * 错误类型枚举
         */
        enum ErrorType {
            PROCESSING_ERROR,
            TIMEOUT_ERROR,
            VALIDATION_ERROR,
            CONFIGURATION_ERROR,
            UNKNOWN_ERROR
        }
    }
    
    /**
     * 批处理配置接口
     */
    interface BatchConfig {
        
        /**
         * 获取批次大小
         * 
         * @return 批次大小
         */
        int getBatchSize();
        
        /**
         * 获取最大并发数
         * 
         * @return 最大并发数
         */
        int getMaxConcurrency();
        
        /**
         * 获取超时时间（毫秒）
         * 
         * @return 超时时间
         */
        long getTimeout();
        
        /**
         * 是否启用错误恢复
         * 
         * @return 是否启用错误恢复
         */
        boolean isErrorRecoveryEnabled();
        
        /**
         * 获取重试次数
         * 
         * @return 重试次数
         */
        int getRetryCount();
        
        /**
         * 是否启用进度监控
         * 
         * @return 是否启用进度监控
         */
        boolean isProgressMonitoringEnabled();
        
        /**
         * 是否启用性能监控
         * 
         * @return 是否启用性能监控
         */
        boolean isPerformanceMonitoringEnabled();
    }
    
    /**
     * 批处理监听器接口
     */
    interface BatchListener<T, R> {
        
        /**
         * 批处理开始
         * 
         * @param totalCount 总数量
         */
        void onBatchStart(int totalCount);
        
        /**
         * 批处理进度
         * 
         * @param processedCount 已处理数量
         * @param totalCount 总数量
         */
        void onBatchProgress(int processedCount, int totalCount);
        
        /**
         * 批处理完成
         * 
         * @param result 批处理结果
         */
        void onBatchComplete(BatchResult<R> result);
        
        /**
         * 批处理错误
         * 
         * @param error 批处理错误
         */
        void onBatchError(BatchError<R> error);
    }
    
    /**
     * 批处理统计信息接口
     */
    interface BatchStatistics {
        
        /**
         * 获取总批次数
         * 
         * @return 总批次数
         */
        long getTotalBatches();
        
        /**
         * 获取总处理数量
         * 
         * @return 总处理数量
         */
        long getTotalProcessed();
        
        /**
         * 获取总成功数量
         * 
         * @return 总成功数量
         */
        long getTotalSuccess();
        
        /**
         * 获取总失败数量
         * 
         * @return 总失败数量
         */
        long getTotalFailures();
        
        /**
         * 获取平均处理时间（毫秒）
         * 
         * @return 平均处理时间
         */
        double getAverageProcessingTime();
        
        /**
         * 获取最大处理时间（毫秒）
         * 
         * @return 最大处理时间
         */
        long getMaxProcessingTime();
        
        /**
         * 获取最小处理时间（毫秒）
         * 
         * @return 最小处理时间
         */
        long getMinProcessingTime();
        
        /**
         * 获取吞吐量（操作/秒）
         * 
         * @return 吞吐量
         */
        double getThroughput();
        
        /**
         * 获取平均成功率
         * 
         * @return 平均成功率
         */
        double getAverageSuccessRate();
    }
}
